import Mock from "mockjs";
import qs from "qs";

const Random = Mock.Random;

// 设置拦截ajax请求的相应时间
Mock.setup({
    timeout: "200-600",
});

Mock.Random.extend({
    titleText: function() {
        let title_text = [
            "delectus aut autem",
            "ok ok ok ok ok ok",
            "one more Time",
        ];
        return this.pick(title_text);
    },
});
// 扩展手机号
Mock.Random.extend({
    phone: function() {
        // let phonePrefixs = ['132', '135', '189']
        // return this.pick(phonePrefixs) + Mock.mock(/\d{8}/)
        return this.pick(Mock.mock(/^(?:(?:\+|00)86)?1[3-9]\d{9}$/));
    },
});
var studentList = []; // 存储
/**
 * http://localhost:3000/api/students GET Mock拦截 查询学生列表数据
 */
{
    const getStudentList = function(urlRelative) {
        // urlRelative 为该次请求相关数据，包括 body、type、url, 如果不传请求参数的话body默认为null
        // console.log(urlRelative);
        if (studentList.length == 0) {
            for (let i = 0; i < 100; i++) {
                let newStudentObj = {
                    id: Random.id(),
                    name: Random.cname(),
                    age: Random.integer(18, 38),
                    sex: Random.integer(1, 2) + "",
                    number: Random.integer(1, 10000),
                    class: Random.integer(1, 10),
                    state: Random.integer(1, 3) + "",
                    address: Random.county(true),
                    phone: Random.phone(),
                };
                studentList.push(newStudentObj);
            }
        }
        // 判断是否有body的查询条件传入，如果有则赛选出符合条件的，如果没有则原样返回
        let resData = studentList; // 默认是认为它是无条件查询所有
        // console.log(JSON.parse(urlRelative.body));
        if (urlRelative.body) {
            urlRelative.body = JSON.parse(urlRelative.body); // 由于urlRelative.body返回来是一个json格式的字符串，因此需要转一下
            resData = studentList.filter((item) => {
                return item.name.indexOf(urlRelative.body.name) !== -1; // 返回所有name字符串中存在 条件传过来的字符串
            });
        }
        return {
            status: 200,
            message: "获取数据成功",
            data: resData,
            total: resData.length,
        };
    };

    Mock.mock("http://localhost:3000/api/students", /get/i, getStudentList);
}

/**
 * http://localhost:3000/api/students/:id DELETE Mock拦截, 根据id删除操作
 */
{
    function deleteOneFromStudent(res) {
        // 截取出 :id 的值，然后进行一个删除对应项 (可以通过从students/后面开始截取所有)
        let reg = /^http:\/\/localhost:3000\/api\/students\/([A-Za-z0-9]+)$/; // 利用（挖出来 :id ）
        let id = res.url.match(reg)[1]; // match 返回的是该字符串中正则匹配的所有字符串，第一个是整体，之后的是括号内的匹配内容
        let resObj = {
            // 响应的数据
            status: 401,
            message: "删除失败",
        };
        if (studentList.length !== 0 && id.length !== 0) {
            // 存在studentList和id的时候才会进行查询删除
            // 通过过滤然后再重新赋值来达到在原有数据删除的效果
            // studentList = studentList.filter((item) => {
            //     return item.id != id;
            // });
            // 利用some函数，当返回true时则停止循环，还有通过splice对原数组进行的一个删除操作 第一个参数是从第几个索引开始 第二个参数是删除几个 最后会影响回原数组。some好处就是不用遍历完全部
            studentList.some((item, index) => {
                if (item.id == id) {
                    studentList.splice(index, 1);
                    return true;
                }
            });
            resObj = {
                status: 200,
                message: "删除成功",
            };
        }
        return resObj;
    }
    Mock.mock(
        // http://localhost:3000/api/students/:id
        // 利用正则表达式解决RETSful风格的传参 拦截
        /^http:\/\/localhost:3000\/api\/students\/[A-Za-z0-9]+$/,
        /delete/i,
        deleteOneFromStudent
    );
}

/**
 * 获得信息列表信息 http://localhost:3000/api/info GET Mock拦截 查询信息列表数据
 */
{
    var infoList = [];

    function getInfoList(res) {
        if (infoList.length === 0) {
            // 当没有数据的时候才会去生成新的数据
            for (let i = 0; i < 10; i++) {
                let clast = Random.clast();
                let newInfoItem = {
                    id: Random.id(),
                    name: clast + Random.cname().slice(1),
                    age: Random.natural(18, 38),
                    sex: Random.natural(1, 2) + "",
                    father: clast + Random.cname().slice(1),
                    mather: Random.cname(),
                    reginTime: Random.date("yyyy-MM-dd"),
                    address: Random.county(true),
                    phone: Random.phone(),
                };
                infoList.push(newInfoItem);
            }
        }
        return {
            status: 200,
            message: "获取数据成功",
            data: infoList,
            total: infoList.length,
        };
    }

    Mock.mock("http://localhost:3000/api/info", /get/i, getInfoList);
}

/**
 * 添加信息列表信息或修改 "http://localhost:3000/api/info"  post 或 put
 */
{
    function addInfoItem({ body: data, type }) {
        data = JSON.parse(data);
        let resObj = {
            status: 400,
            message: "添加失败",
        };

        if (
            data.name.length != 0 &&
            data.age.length != 0 &&
            data.name.length != 0 &&
            data.phone.length != 0 &&
            data.reginTime.length != 0 &&
            data.sex.length != 0
        ) {
            if (type == "put" || type == "PUT") {
                // 如果传过来的数据存在id, 说明是修改数据, 也可以通过传过来的method判断是post还是put
                infoList.some((item, index) => {
                    if (item.id == data.id) {
                        // 找对对应的id，修改数据即可
                        infoList[index] = data;
                        return true;
                    }
                });
                resObj = {
                    status: 200,
                    message: "修改数据成功",
                    data,
                };
            } else {
                data["id"] = Random.id(); // 添加数据的时候为它加个id
                infoList.push(data);
                resObj = {
                    status: 200,
                    message: "添加数据成功",
                    data,
                };
            }
        }
        return resObj;
    }
    Mock.mock("http://localhost:3000/api/info", /post|put/i, addInfoItem);
}

/**
 * 根据id删除列表信息
 */
{
    function deleteInfoItem({ url }) {
        let reg = /^http:\/\/localhost:3000\/api\/info\/([A-Za-z0-9]+)$/;
        let id = url.match(reg)[1];
        let resObj = {
            // 响应的数据
            status: 401,
            message: "删除失败",
        };
        if (id) {
            // 说明挖取成功
            if (infoList.length != 0) {
                // 有数据可以删除
                infoList.some((item, index) => {
                    if (item.id == id) {
                        infoList.splice(index, 1);
                        return true;
                    }
                });
                resObj = {
                    status: 200,
                    message: "删除成功",
                };
            }
        }
        return resObj;
    }

    Mock.mock(
        /^http:\/\/localhost:3000\/api\/info\/[A-Za-z0-9]+$/,
        /delete/i,
        deleteInfoItem
    );
}

/**
 * 作业请求： http://localhost:3000/api/works GET
 */
{
    var works = [];

    function getWorks(res) {
        let url = res.url;
        let reg = /^http:\/\/localhost:3000\/api\/works\?*([a-zA-z0-9_=&]+)$/;
        let { page, size } = qs.parse(url.match(reg)[1]);
        if (works.length == 0) {
            for (let i = 0; i < 100; i++) {
                let work = {
                    id: Random.id(),
                    userId: Random.natural(1, 10),
                    title: Random.titleText(),
                    completed: Random.boolean(),
                };
                works.push(work);
            }
        }

        let resObj = {
            status: 200,
            message: "获取数据成功",
            data: works.slice((page - 1) * size, page * size),
            total: works.length,
        };

        return resObj;
    }
    Mock.mock(
        /^http:\/\/localhost:3000\/api\/works\?*[a-zA-z0-9_=&]+$/,
        /get/i,
        getWorks
    );
}